import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        try {
            apiInstance.acmeDnsAuthenticatorAuthenticatorSchemasGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorAuthenticatorSchemasGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();

eval { 
    $api_instance->acmeDnsAuthenticatorAuthenticatorSchemasGet();
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()

try: 
    api_instance.acme_dns_authenticator_authenticator_schemas_get()
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorAuthenticatorSchemasGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 

try: 
    api_instance.acme_dns_authenticator_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Integer id = 56; // Integer | 
        Acme_dns_authenticator_update_1 body = ; // Acme_dns_authenticator_update_1 | 
        try {
            apiInstance.acmeDnsAuthenticatorIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Acme_dns_authenticator_update_1->new(); # Acme_dns_authenticator_update_1 | 

eval { 
    $api_instance->acmeDnsAuthenticatorIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
id = 56 # Integer | 
body =  # Acme_dns_authenticator_update_1 |  (optional)

try: 
    api_instance.acme_dns_authenticator_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AcmeDnsAuthenticatorApi;

import java.io.File;
import java.util.*;

public class AcmeDnsAuthenticatorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AcmeDnsAuthenticatorApi apiInstance = new AcmeDnsAuthenticatorApi();
        Acme_dns_authenticator_create_0 body = ; // Acme_dns_authenticator_create_0 | 
        try {
            apiInstance.acmeDnsAuthenticatorPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AcmeDnsAuthenticatorApi#acmeDnsAuthenticatorPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AcmeDnsAuthenticatorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AcmeDnsAuthenticatorApi->new();
my $body = WWW::SwaggerClient::Object::Acme_dns_authenticator_create_0->new(); # Acme_dns_authenticator_create_0 | 

eval { 
    $api_instance->acmeDnsAuthenticatorPost(body => $body);
};
if ($@) {
    warn "Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AcmeDnsAuthenticatorApi()
body =  # Acme_dns_authenticator_create_0 |  (optional)

try: 
    api_instance.acme_dns_authenticator_post(body=body)
except ApiException as e:
    print("Exception when calling AcmeDnsAuthenticatorApi->acmeDnsAuthenticatorPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryChangeTrustAccountPwGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryChangeTrustAccountPwGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryChangeTrustAccountPwGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_change_trust_account_pw_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryChangeTrustAccountPwGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryDomainInfoGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryDomainInfoGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryDomainInfoGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_domain_info_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryDomainInfoGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetSpnListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetSpnListGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGetSpnListGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get_spn_list_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetSpnListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryGetStateGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryGetStateGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_get_state_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryGetStateGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        Activedirectory_leave_0 body = ; // Activedirectory_leave_0 | 
        try {
            apiInstance.activedirectoryLeavePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryLeavePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();
my $body = WWW::SwaggerClient::Object::Activedirectory_leave_0->new(); # Activedirectory_leave_0 | 

eval { 
    $api_instance->activedirectoryLeavePost(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryLeavePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_leave_0 |  (optional)

try: 
    api_instance.activedirectory_leave_post(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryLeavePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryNssInfoChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryNssInfoChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryNssInfoChoicesGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_nss_info_choices_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryNssInfoChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        Activedirectory_update_0 body = ; // Activedirectory_update_0 | 
        try {
            apiInstance.activedirectoryPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();
my $body = WWW::SwaggerClient::Object::Activedirectory_update_0->new(); # Activedirectory_update_0 | 

eval { 
    $api_instance->activedirectoryPut(body => $body);
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()
body =  # Activedirectory_update_0 |  (optional)

try: 
    api_instance.activedirectory_put(body=body)
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ActivedirectoryApi;

import java.io.File;
import java.util.*;

public class ActivedirectoryApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ActivedirectoryApi apiInstance = new ActivedirectoryApi();
        try {
            apiInstance.activedirectoryStartedGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling ActivedirectoryApi#activedirectoryStartedGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ActivedirectoryApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ActivedirectoryApi->new();

eval { 
    $api_instance->activedirectoryStartedGet();
};
if ($@) {
    warn "Exception when calling ActivedirectoryApi->activedirectoryStartedGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ActivedirectoryApi()

try: 
    api_instance.activedirectory_started_get()
except ApiException as e:
    print("Exception when calling ActivedirectoryApi->activedirectoryStartedGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpBindipChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpBindipChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();

eval { 
    $api_instance->afpBindipChoicesGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpBindipChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()

try: 
    api_instance.afp_bindip_choices_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpBindipChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        try {
            apiInstance.afpGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();

eval { 
    $api_instance->afpGet();
};
if ($@) {
    warn "Exception when calling AfpApi->afpGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()

try: 
    api_instance.afp_get()
except ApiException as e:
    print("Exception when calling AfpApi->afpGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AfpApi;

import java.io.File;
import java.util.*;

public class AfpApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AfpApi apiInstance = new AfpApi();
        Afp_update_0 body = ; // Afp_update_0 | 
        try {
            apiInstance.afpPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AfpApi#afpPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AfpApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AfpApi->new();
my $body = WWW::SwaggerClient::Object::Afp_update_0->new(); # Afp_update_0 | 

eval { 
    $api_instance->afpPut(body => $body);
};
if ($@) {
    warn "Exception when calling AfpApi->afpPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AfpApi()
body =  # Afp_update_0 |  (optional)

try: 
    api_instance.afp_put(body=body)
except ApiException as e:
    print("Exception when calling AfpApi->afpPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        String body = ; // String | 
        try {
            apiInstance.alertDismissPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertDismissPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->alertDismissPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertDismissPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_dismiss_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertDismissPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListCategoriesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListCategoriesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListCategoriesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListCategoriesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_categories_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListCategoriesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        try {
            apiInstance.alertListPoliciesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertListPoliciesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();

eval { 
    $api_instance->alertListPoliciesGet();
};
if ($@) {
    warn "Exception when calling AlertApi->alertListPoliciesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()

try: 
    api_instance.alert_list_policies_get()
except ApiException as e:
    print("Exception when calling AlertApi->alertListPoliciesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertApi;

import java.io.File;
import java.util.*;

public class AlertApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertApi apiInstance = new AlertApi();
        String body = ; // String | 
        try {
            apiInstance.alertRestorePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#alertRestorePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->alertRestorePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertApi->alertRestorePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertApi()
body =  # String |  (optional)

try: 
    api_instance.alert_restore_post(body=body)
except ApiException as e:
    print("Exception when calling AlertApi->alertRestorePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

import java.io.File;
import java.util.*;

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertclassesApi apiInstance = new AlertclassesApi();
        try {
            apiInstance.alertclassesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertclassesApi#alertclassesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertclassesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertclassesApi->new();

eval { 
    $api_instance->alertclassesGet();
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertclassesApi()

try: 
    api_instance.alertclasses_get()
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertclassesApi;

import java.io.File;
import java.util.*;

public class AlertclassesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertclassesApi apiInstance = new AlertclassesApi();
        Alertclasses_update_0 body = ; // Alertclasses_update_0 | 
        try {
            apiInstance.alertclassesPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertclassesApi#alertclassesPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertclassesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertclassesApi->new();
my $body = WWW::SwaggerClient::Object::Alertclasses_update_0->new(); # Alertclasses_update_0 | 

eval { 
    $api_instance->alertclassesPut(body => $body);
};
if ($@) {
    warn "Exception when calling AlertclassesApi->alertclassesPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertclassesApi()
body =  # Alertclasses_update_0 |  (optional)

try: 
    api_instance.alertclasses_put(body=body)
except ApiException as e:
    print("Exception when calling AlertclassesApi->alertclassesPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.alertserviceIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->alertserviceIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 

try: 
    api_instance.alertservice_id_id_delete(id)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.alertserviceIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->alertserviceIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.alertservice_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Integer id = 56; // Integer | 
        Alertservice_update_1 body = ; // Alertservice_update_1 | 
        try {
            apiInstance.alertserviceIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Alertservice_update_1->new(); # Alertservice_update_1 | 

eval { 
    $api_instance->alertserviceIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
id = 56 # Integer | 
body =  # Alertservice_update_1 |  (optional)

try: 
    api_instance.alertservice_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        try {
            apiInstance.alertserviceListTypesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceListTypesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();

eval { 
    $api_instance->alertserviceListTypesGet();
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceListTypesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()

try: 
    api_instance.alertservice_list_types_get()
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceListTypesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Alertservice_create_0 body = ; // Alertservice_create_0 | 
        try {
            apiInstance.alertservicePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertservicePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $body = WWW::SwaggerClient::Object::Alertservice_create_0->new(); # Alertservice_create_0 | 

eval { 
    $api_instance->alertservicePost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertservicePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_create_0 |  (optional)

try: 
    api_instance.alertservice_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertservicePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AlertserviceApi;

import java.io.File;
import java.util.*;

public class AlertserviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AlertserviceApi apiInstance = new AlertserviceApi();
        Alertservice_test_0 body = ; // Alertservice_test_0 | 
        try {
            apiInstance.alertserviceTestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertserviceApi#alertserviceTestPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AlertserviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AlertserviceApi->new();
my $body = WWW::SwaggerClient::Object::Alertservice_test_0->new(); # Alertservice_test_0 | 

eval { 
    $api_instance->alertserviceTestPost(body => $body);
};
if ($@) {
    warn "Exception when calling AlertserviceApi->alertserviceTestPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AlertserviceApi()
body =  # Alertservice_test_0 |  (optional)

try: 
    api_instance.alertservice_test_post(body=body)
except ApiException as e:
    print("Exception when calling AlertserviceApi->alertserviceTestPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiKeyIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiKeyIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 

try: 
    api_instance.api_key_id_id_delete(id)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.apiKeyIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->apiKeyIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.api_key_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Integer id = 56; // Integer | 
        Api_key_update_1 body = ; // Api_key_update_1 | 
        try {
            apiInstance.apiKeyIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Api_key_update_1->new(); # Api_key_update_1 | 

eval { 
    $api_instance->apiKeyIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
id = 56 # Integer | 
body =  # Api_key_update_1 |  (optional)

try: 
    api_instance.api_key_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiKeyApi;

import java.io.File;
import java.util.*;

public class ApiKeyApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ApiKeyApi apiInstance = new ApiKeyApi();
        Api_key_create_0 body = ; // Api_key_create_0 | 
        try {
            apiInstance.apiKeyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiKeyApi#apiKeyPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ApiKeyApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiKeyApi->new();
my $body = WWW::SwaggerClient::Object::Api_key_create_0->new(); # Api_key_create_0 | 

eval { 
    $api_instance->apiKeyPost(body => $body);
};
if ($@) {
    warn "Exception when calling ApiKeyApi->apiKeyPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiKeyApi()
body =  # Api_key_create_0 |  (optional)

try: 
    api_instance.api_key_post(body=body)
except ApiException as e:
    print("Exception when calling ApiKeyApi->apiKeyPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Auth_check_user body = ; // Auth_check_user | 
        try {
            apiInstance.authCheckUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authCheckUserPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $body = WWW::SwaggerClient::Object::Auth_check_user->new(); # Auth_check_user | 

eval { 
    $api_instance->authCheckUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authCheckUserPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_check_user |  (optional)

try: 
    api_instance.auth_check_user_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authCheckUserPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Auth_generate_token body = ; // Auth_generate_token | 
        try {
            apiInstance.authGenerateTokenPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGenerateTokenPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $body = WWW::SwaggerClient::Object::Auth_generate_token->new(); # Auth_generate_token | 

eval { 
    $api_instance->authGenerateTokenPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthApi->authGenerateTokenPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
body =  # Auth_generate_token |  (optional)

try: 
    api_instance.auth_generate_token_post(body=body)
except ApiException as e:
    print("Exception when calling AuthApi->authGenerateTokenPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.authSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authSessionsGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->authSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling AuthApi->authSessionsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.auth_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling AuthApi->authSessionsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthApi apiInstance = new AuthApi();
        try {
            apiInstance.authTwoFactorAuthGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authTwoFactorAuthGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthApi->new();

eval { 
    $api_instance->authTwoFactorAuthGet();
};
if ($@) {
    warn "Exception when calling AuthApi->authTwoFactorAuthGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthApi()

try: 
    api_instance.auth_two_factor_auth_get()
except ApiException as e:
    print("Exception when calling AuthApi->authTwoFactorAuthGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorProvisioningUriGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorProvisioningUriGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorProvisioningUriGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_provisioning_uri_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorProvisioningUriGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        Auth_twofactor_update_0 body = ; // Auth_twofactor_update_0 | 
        try {
            apiInstance.authTwofactorPut(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();
my $body = WWW::SwaggerClient::Object::Auth_twofactor_update_0->new(); # Auth_twofactor_update_0 | 

eval { 
    $api_instance->authTwofactorPut(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # Auth_twofactor_update_0 |  (optional)

try: 
    api_instance.auth_twofactor_put(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        try {
            apiInstance.authTwofactorRenewSecretGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorRenewSecretGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();

eval { 
    $api_instance->authTwofactorRenewSecretGet();
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()

try: 
    api_instance.auth_twofactor_renew_secret_get()
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorRenewSecretGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthTwofactorApi;

import java.io.File;
import java.util.*;

public class AuthTwofactorApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        AuthTwofactorApi apiInstance = new AuthTwofactorApi();
        String body = ; // String | 
        try {
            apiInstance.authTwofactorVerifyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthTwofactorApi#authTwofactorVerifyPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AuthTwofactorApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::AuthTwofactorApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->authTwofactorVerifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.AuthTwofactorApi()
body =  # String |  (optional)

try: 
    api_instance.auth_twofactor_verify_post(body=body)
except ApiException as e:
    print("Exception when calling AuthTwofactorApi->authTwofactorVerifyPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Boot_attach body = ; // Boot_attach | 
        try {
            apiInstance.bootAttachPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootAttachPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Boot_attach->new(); # Boot_attach | 

eval { 
    $api_instance->bootAttachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootAttachPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_attach |  (optional)

try: 
    api_instance.boot_attach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootAttachPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        String body = ; // String | 
        try {
            apiInstance.bootDetachPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootDetachPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->bootDetachPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootDetachPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # String |  (optional)

try: 
    api_instance.boot_detach_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootDetachPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetDisksGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetDisksGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetDisksGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetDisksGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_disks_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetDisksGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetScrubIntervalGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetScrubIntervalGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetScrubIntervalGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetScrubIntervalGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_scrub_interval_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetScrubIntervalGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootGetStateGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootGetStateGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootGetStateGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_get_state_get()
except ApiException as e:
    print("Exception when calling BootApi->bootGetStateGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Boot_replace body = ; // Boot_replace | 
        try {
            apiInstance.bootReplacePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootReplacePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Boot_replace->new(); # Boot_replace | 

eval { 
    $api_instance->bootReplacePost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootReplacePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Boot_replace |  (optional)

try: 
    api_instance.boot_replace_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootReplacePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        try {
            apiInstance.bootScrubGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootScrubGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();

eval { 
    $api_instance->bootScrubGet();
};
if ($@) {
    warn "Exception when calling BootApi->bootScrubGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()

try: 
    api_instance.boot_scrub_get()
except ApiException as e:
    print("Exception when calling BootApi->bootScrubGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootApi;

import java.io.File;
import java.util.*;

public class BootApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootApi apiInstance = new BootApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.bootSetScrubIntervalPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootApi#bootSetScrubIntervalPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->bootSetScrubIntervalPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootApi->bootSetScrubIntervalPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootApi()
body =  # Integer |  (optional)

try: 
    api_instance.boot_set_scrub_interval_post(body=body)
except ApiException as e:
    print("Exception when calling BootApi->bootSetScrubIntervalPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_activate body = ; // Bootenv_activate | 
        try {
            apiInstance.bootenvIdIdActivatePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdActivatePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_activate->new(); # Bootenv_activate | 

eval { 
    $api_instance->bootenvIdIdActivatePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdActivatePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_activate |  (optional)

try: 
    api_instance.bootenv_id_id_activate_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdActivatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        try {
            apiInstance.bootenvIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->bootenvIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 

try: 
    api_instance.bootenv_id_id_delete(id)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.bootenvIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->bootenvIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.bootenv_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_update_1 body = ; // Bootenv_update_1 | 
        try {
            apiInstance.bootenvIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_update_1->new(); # Bootenv_update_1 | 

eval { 
    $api_instance->bootenvIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_update_1 |  (optional)

try: 
    api_instance.bootenv_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        String id = id_example; // String | 
        Bootenv_set_attribute_1 body = ; // Bootenv_set_attribute_1 | 
        try {
            apiInstance.bootenvIdIdSetAttributePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvIdIdSetAttributePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $id = id_example; # String | 
my $body = WWW::SwaggerClient::Object::Bootenv_set_attribute_1->new(); # Bootenv_set_attribute_1 | 

eval { 
    $api_instance->bootenvIdIdSetAttributePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvIdIdSetAttributePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
id = id_example # String | 
body =  # Bootenv_set_attribute_1 |  (optional)

try: 
    api_instance.bootenv_id_id_set_attribute_post(id, body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvIdIdSetAttributePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.BootenvApi;

import java.io.File;
import java.util.*;

public class BootenvApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        BootenvApi apiInstance = new BootenvApi();
        Bootenv_create_0 body = ; // Bootenv_create_0 | 
        try {
            apiInstance.bootenvPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BootenvApi#bootenvPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::BootenvApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::BootenvApi->new();
my $body = WWW::SwaggerClient::Object::Bootenv_create_0->new(); # Bootenv_create_0 | 

eval { 
    $api_instance->bootenvPost(body => $body);
};
if ($@) {
    warn "Exception when calling BootenvApi->bootenvPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.BootenvApi()
body =  # Bootenv_create_0 |  (optional)

try: 
    api_instance.bootenv_post(body=body)
except ApiException as e:
    print("Exception when calling BootenvApi->bootenvPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateAcmeServerChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateAcmeServerChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateAcmeServerChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateAcmeServerChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_acme_server_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateAcmeServerChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateCountryChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateCountryChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateCountryChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateCountryChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_country_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateCountryChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateEcCurveChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateEcCurveChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateEcCurveChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateEcCurveChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_ec_curve_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateEcCurveChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateExtendedKeyUsageChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateExtendedKeyUsageChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateExtendedKeyUsageChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_extended_key_usage_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateExtendedKeyUsageChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Boolean body = ; // Boolean | 
        try {
            apiInstance.certificateIdIdDelete(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->certificateIdIdDelete(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id = 56 # Integer | 
body =  # Boolean |  (optional)

try: 
    api_instance.certificate_id_id_delete(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificate_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Integer id = 56; // Integer | 
        Certificate_update_1 body = ; // Certificate_update_1 | 
        try {
            apiInstance.certificateIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Certificate_update_1->new(); # Certificate_update_1 | 

eval { 
    $api_instance->certificateIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
id = 56 # Integer | 
body =  # Certificate_update_1 |  (optional)

try: 
    api_instance.certificate_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificateIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateKeyTypeChoicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateKeyTypeChoicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateKeyTypeChoicesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateKeyTypeChoicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_key_type_choices_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateKeyTypeChoicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        Certificate_create_0 body = ; // Certificate_create_0 | 
        try {
            apiInstance.certificatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificatePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();
my $body = WWW::SwaggerClient::Object::Certificate_create_0->new(); # Certificate_create_0 | 

eval { 
    $api_instance->certificatePost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateApi->certificatePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()
body =  # Certificate_create_0 |  (optional)

try: 
    api_instance.certificate_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateApi->certificatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateApi;

import java.io.File;
import java.util.*;

public class CertificateApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateApi apiInstance = new CertificateApi();
        try {
            apiInstance.certificateProfilesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateApi#certificateProfilesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateApi->new();

eval { 
    $api_instance->certificateProfilesGet();
};
if ($@) {
    warn "Exception when calling CertificateApi->certificateProfilesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateApi()

try: 
    api_instance.certificate_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateApi->certificateProfilesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Certificateauthority_ca_sign_csr_0 body = ; // Certificateauthority_ca_sign_csr_0 | 
        try {
            apiInstance.certificateauthorityCaSignCsrPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityCaSignCsrPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $body = WWW::SwaggerClient::Object::Certificateauthority_ca_sign_csr_0->new(); # Certificateauthority_ca_sign_csr_0 | 

eval { 
    $api_instance->certificateauthorityCaSignCsrPost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityCaSignCsrPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
body =  # Certificateauthority_ca_sign_csr_0 |  (optional)

try: 
    api_instance.certificateauthority_ca_sign_csr_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityCaSignCsrPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateauthorityGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificateauthority_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.certificateauthorityIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->certificateauthorityIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id = 56 # Integer | 

try: 
    api_instance.certificateauthority_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.certificateauthorityIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->certificateauthorityIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.certificateauthority_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Integer id = 56; // Integer | 
        Certificateauthority_update_1 body = ; // Certificateauthority_update_1 | 
        try {
            apiInstance.certificateauthorityIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Certificateauthority_update_1->new(); # Certificateauthority_update_1 | 

eval { 
    $api_instance->certificateauthorityIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
id = 56 # Integer | 
body =  # Certificateauthority_update_1 |  (optional)

try: 
    api_instance.certificateauthority_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        Certificateauthority_create_0 body = ; // Certificateauthority_create_0 | 
        try {
            apiInstance.certificateauthorityPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();
my $body = WWW::SwaggerClient::Object::Certificateauthority_create_0->new(); # Certificateauthority_create_0 | 

eval { 
    $api_instance->certificateauthorityPost(body => $body);
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()
body =  # Certificateauthority_create_0 |  (optional)

try: 
    api_instance.certificateauthority_post(body=body)
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CertificateauthorityApi;

import java.io.File;
import java.util.*;

public class CertificateauthorityApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CertificateauthorityApi apiInstance = new CertificateauthorityApi();
        try {
            apiInstance.certificateauthorityProfilesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CertificateauthorityApi#certificateauthorityProfilesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CertificateauthorityApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CertificateauthorityApi->new();

eval { 
    $api_instance->certificateauthorityProfilesGet();
};
if ($@) {
    warn "Exception when calling CertificateauthorityApi->certificateauthorityProfilesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CertificateauthorityApi()

try: 
    api_instance.certificateauthority_profiles_get()
except ApiException as e:
    print("Exception when calling CertificateauthorityApi->certificateauthorityProfilesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        try {
            apiInstance.cloudsyncCommonTaskSchemaGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncCommonTaskSchemaGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();

eval { 
    $api_instance->cloudsyncCommonTaskSchemaGet();
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncCommonTaskSchemaGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()

try: 
    api_instance.cloudsync_common_task_schema_get()
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncCommonTaskSchemaGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_abort body = ; // Cloudsync_abort | 
        try {
            apiInstance.cloudsyncIdIdAbortPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdAbortPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_abort->new(); # Cloudsync_abort | 

eval { 
    $api_instance->cloudsyncIdIdAbortPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdAbortPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_abort |  (optional)

try: 
    api_instance.cloudsync_id_id_abort_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdAbortPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cloudsyncIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cloudsyncIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 

try: 
    api_instance.cloudsync_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_update_1 body = ; // Cloudsync_update_1 | 
        try {
            apiInstance.cloudsyncIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_update_1->new(); # Cloudsync_update_1 | 

eval { 
    $api_instance->cloudsyncIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_update_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_restore_1 body = ; // Cloudsync_restore_1 | 
        try {
            apiInstance.cloudsyncIdIdRestorePost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdRestorePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_restore_1->new(); # Cloudsync_restore_1 | 

eval { 
    $api_instance->cloudsyncIdIdRestorePost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdRestorePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_restore_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_restore_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdRestorePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer id = 56; // Integer | 
        Cloudsync_sync_1 body = ; // Cloudsync_sync_1 | 
        try {
            apiInstance.cloudsyncIdIdSyncPost(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncIdIdSyncPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_sync_1->new(); # Cloudsync_sync_1 | 

eval { 
    $api_instance->cloudsyncIdIdSyncPost(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncIdIdSyncPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
id = 56 # Integer | 
body =  # Cloudsync_sync_1 |  (optional)

try: 
    api_instance.cloudsync_id_id_sync_post(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncIdIdSyncPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.cloudsyncListBucketsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncListBucketsPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->cloudsyncListBucketsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncListBucketsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Integer |  (optional)

try: 
    api_instance.cloudsync_list_buckets_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListBucketsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_list_directory_0 body = ; // Cloudsync_list_directory_0 | 
        try {
            apiInstance.cloudsyncListDirectoryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncListDirectoryPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_list_directory_0->new(); # Cloudsync_list_directory_0 | 

eval { 
    $api_instance->cloudsyncListDirectoryPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncListDirectoryPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_list_directory_0 |  (optional)

try: 
    api_instance.cloudsync_list_directory_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncListDirectoryPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_onedrive_list_drives_0 body = ; // Cloudsync_onedrive_list_drives_0 | 
        try {
            apiInstance.cloudsyncOnedriveListDrivesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncOnedriveListDrivesPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_onedrive_list_drives_0->new(); # Cloudsync_onedrive_list_drives_0 | 

eval { 
    $api_instance->cloudsyncOnedriveListDrivesPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncOnedriveListDrivesPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_onedrive_list_drives_0 |  (optional)

try: 
    api_instance.cloudsync_onedrive_list_drives_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncOnedriveListDrivesPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_create_0 body = ; // Cloudsync_create_0 | 
        try {
            apiInstance.cloudsyncPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_create_0->new(); # Cloudsync_create_0 | 

eval { 
    $api_instance->cloudsyncPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_create_0 |  (optional)

try: 
    api_instance.cloudsync_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        try {
            apiInstance.cloudsyncProvidersGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncProvidersGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();

eval { 
    $api_instance->cloudsyncProvidersGet();
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncProvidersGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()

try: 
    api_instance.cloudsync_providers_get()
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncProvidersGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncApi;

import java.io.File;
import java.util.*;

public class CloudsyncApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncApi apiInstance = new CloudsyncApi();
        Cloudsync_sync_onetime body = ; // Cloudsync_sync_onetime | 
        try {
            apiInstance.cloudsyncSyncOnetimePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncApi#cloudsyncSyncOnetimePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_sync_onetime->new(); # Cloudsync_sync_onetime | 

eval { 
    $api_instance->cloudsyncSyncOnetimePost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncApi->cloudsyncSyncOnetimePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncApi()
body =  # Cloudsync_sync_onetime |  (optional)

try: 
    api_instance.cloudsync_sync_onetime_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncApi->cloudsyncSyncOnetimePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncCredentialsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncCredentialsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_credentials_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cloudsyncCredentialsIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id = 56 # Integer | 

try: 
    api_instance.cloudsync_credentials_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cloudsyncCredentialsIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cloudsync_credentials_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Integer id = 56; // Integer | 
        Cloudsync_credentials_update_1 body = ; // Cloudsync_credentials_update_1 | 
        try {
            apiInstance.cloudsyncCredentialsIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_update_1->new(); # Cloudsync_credentials_update_1 | 

eval { 
    $api_instance->cloudsyncCredentialsIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
id = 56 # Integer | 
body =  # Cloudsync_credentials_update_1 |  (optional)

try: 
    api_instance.cloudsync_credentials_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Cloudsync_credentials_create_0 body = ; // Cloudsync_credentials_create_0 | 
        try {
            apiInstance.cloudsyncCredentialsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_create_0->new(); # Cloudsync_credentials_create_0 | 

eval { 
    $api_instance->cloudsyncCredentialsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
body =  # Cloudsync_credentials_create_0 |  (optional)

try: 
    api_instance.cloudsync_credentials_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CloudsyncCredentialsApi;

import java.io.File;
import java.util.*;

public class CloudsyncCredentialsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CloudsyncCredentialsApi apiInstance = new CloudsyncCredentialsApi();
        Cloudsync_credentials_verify_0 body = ; // Cloudsync_credentials_verify_0 | 
        try {
            apiInstance.cloudsyncCredentialsVerifyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CloudsyncCredentialsApi#cloudsyncCredentialsVerifyPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CloudsyncCredentialsApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CloudsyncCredentialsApi->new();
my $body = WWW::SwaggerClient::Object::Cloudsync_credentials_verify_0->new(); # Cloudsync_credentials_verify_0 | 

eval { 
    $api_instance->cloudsyncCredentialsVerifyPost(body => $body);
};
if ($@) {
    warn "Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsVerifyPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CloudsyncCredentialsApi()
body =  # Cloudsync_credentials_verify_0 |  (optional)

try: 
    api_instance.cloudsync_credentials_verify_post(body=body)
except ApiException as e:
    print("Exception when calling CloudsyncCredentialsApi->cloudsyncCredentialsVerifyPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ConfigApi;

import java.io.File;
import java.util.*;

public class ConfigApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        ConfigApi apiInstance = new ConfigApi();
        Config_reset_0 body = ; // Config_reset_0 | 
        try {
            apiInstance.configResetPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConfigApi#configResetPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ConfigApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ConfigApi->new();
my $body = WWW::SwaggerClient::Object::Config_reset_0->new(); # Config_reset_0 | 

eval { 
    $api_instance->configResetPost(body => $body);
};
if ($@) {
    warn "Exception when calling ConfigApi->configResetPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ConfigApi()
body =  # Config_reset_0 |  (optional)

try: 
    api_instance.config_reset_post(body=body)
except ApiException as e:
    print("Exception when calling ConfigApi->configResetPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_bulk body = ; // Core_bulk | 
        try {
            apiInstance.coreBulkPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreBulkPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_bulk->new(); # Core_bulk | 

eval { 
    $api_instance->coreBulkPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreBulkPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_bulk |  (optional)

try: 
    api_instance.core_bulk_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreBulkPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_debug body = ; // Core_debug | 
        try {
            apiInstance.coreDebugPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreDebugPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_debug->new(); # Core_debug | 

eval { 
    $api_instance->coreDebugPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreDebugPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_debug |  (optional)

try: 
    api_instance.core_debug_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreDebugPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_download body = ; // Core_download | 
        try {
            apiInstance.coreDownloadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreDownloadPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_download->new(); # Core_download | 

eval { 
    $api_instance->coreDownloadPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreDownloadPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_download |  (optional)

try: 
    api_instance.core_download_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreDownloadPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.coreGetEventsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetEventsGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->coreGetEventsGet();
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetEventsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_get_events_get()
except ApiException as e:
    print("Exception when calling CoreApi->coreGetEventsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.coreGetJobsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetJobsGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->coreGetJobsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetJobsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.core_get_jobs_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CoreApi->coreGetJobsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        String body = ; // String | 
        try {
            apiInstance.coreGetMethodsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetMethodsPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->coreGetMethodsPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetMethodsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # String |  (optional)

try: 
    api_instance.core_get_methods_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreGetMethodsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.coreGetServicesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreGetServicesGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->coreGetServicesGet();
};
if ($@) {
    warn "Exception when calling CoreApi->coreGetServicesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_get_services_get()
except ApiException as e:
    print("Exception when calling CoreApi->coreGetServicesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.coreJobAbortPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobAbortPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->coreJobAbortPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobAbortPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Integer |  (optional)

try: 
    api_instance.core_job_abort_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobAbortPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_job_update body = ; // Core_job_update | 
        try {
            apiInstance.coreJobUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobUpdatePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_job_update->new(); # Core_job_update | 

eval { 
    $api_instance->coreJobUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobUpdatePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_job_update |  (optional)

try: 
    api_instance.core_job_update_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobUpdatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer body = ; // Integer | 
        try {
            apiInstance.coreJobWaitPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreJobWaitPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Integer->new(); # Integer | 

eval { 
    $api_instance->coreJobWaitPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreJobWaitPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Integer |  (optional)

try: 
    api_instance.core_job_wait_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreJobWaitPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        try {
            apiInstance.corePingGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#corePingGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();

eval { 
    $api_instance->corePingGet();
};
if ($@) {
    warn "Exception when calling CoreApi->corePingGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()

try: 
    api_instance.core_ping_get()
except ApiException as e:
    print("Exception when calling CoreApi->corePingGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_ping_remote_0 body = ; // Core_ping_remote_0 | 
        try {
            apiInstance.corePingRemotePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#corePingRemotePost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_ping_remote_0->new(); # Core_ping_remote_0 | 

eval { 
    $api_instance->corePingRemotePost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->corePingRemotePost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_ping_remote_0 |  (optional)

try: 
    api_instance.core_ping_remote_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->corePingRemotePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Core_resize_shell body = ; // Core_resize_shell | 
        try {
            apiInstance.coreResizeShellPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreResizeShellPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $body = WWW::SwaggerClient::Object::Core_resize_shell->new(); # Core_resize_shell | 

eval { 
    $api_instance->coreResizeShellPost(body => $body);
};
if ($@) {
    warn "Exception when calling CoreApi->coreResizeShellPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
body =  # Core_resize_shell |  (optional)

try: 
    api_instance.core_resize_shell_post(body=body)
except ApiException as e:
    print("Exception when calling CoreApi->coreResizeShellPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CoreApi;

import java.io.File;
import java.util.*;

public class CoreApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CoreApi apiInstance = new CoreApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.coreSessionsGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CoreApi#coreSessionsGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CoreApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CoreApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->coreSessionsGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CoreApi->coreSessionsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CoreApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.core_sessions_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CoreApi->coreSessionsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cronjobGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cronjobGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cronjob_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.cronjobIdIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdDelete");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->cronjobIdIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id = 56 # Integer | 

try: 
    api_instance.cronjob_id_id_delete(id)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.cronjobIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->cronjobIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.cronjob_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Integer id = 56; // Integer | 
        Cronjob_update_1 body = ; // Cronjob_update_1 | 
        try {
            apiInstance.cronjobIdIdPut(id, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobIdIdPut");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::Cronjob_update_1->new(); # Cronjob_update_1 | 

eval { 
    $api_instance->cronjobIdIdPut(id => $id, body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobIdIdPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
id = 56 # Integer | 
body =  # Cronjob_update_1 |  (optional)

try: 
    api_instance.cronjob_id_id_put(id, body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobIdIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Cronjob_create_0 body = ; // Cronjob_create_0 | 
        try {
            apiInstance.cronjobPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $body = WWW::SwaggerClient::Object::Cronjob_create_0->new(); # Cronjob_create_0 | 

eval { 
    $api_instance->cronjobPost(body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
body =  # Cronjob_create_0 |  (optional)

try: 
    api_instance.cronjob_post(body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CronjobApi;

import java.io.File;
import java.util.*;

public class CronjobApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        CronjobApi apiInstance = new CronjobApi();
        Cronjob_run body = ; // Cronjob_run | 
        try {
            apiInstance.cronjobRunPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CronjobApi#cronjobRunPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CronjobApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::CronjobApi->new();
my $body = WWW::SwaggerClient::Object::Cronjob_run->new(); # Cronjob_run | 

eval { 
    $api_instance->cronjobRunPost(body => $body);
};
if ($@) {
    warn "Exception when calling CronjobApi->cronjobRunPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.CronjobApi()
body =  # Cronjob_run |  (optional)

try: 
    api_instance.cronjob_run_post(body=body)
except ApiException as e:
    print("Exception when calling CronjobApi->cronjobRunPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DeviceApi;

import java.io.File;
import java.util.*;

public class DeviceApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DeviceApi apiInstance = new DeviceApi();
        String body = ; // String | 
        try {
            apiInstance.deviceGetInfoPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeviceApi#deviceGetInfoPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DeviceApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DeviceApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | 

eval { 
    $api_instance->deviceGetInfoPost(body => $body);
};
if ($@) {
    warn "Exception when calling DeviceApi->deviceGetInfoPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DeviceApi()
body =  # String |  (optional)

try: 
    api_instance.device_get_info_post(body=body)
except ApiException as e:
    print("Exception when calling DeviceApi->deviceGetInfoPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DirectoryservicesApi;

import java.io.File;
import java.util.*;

public class DirectoryservicesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DirectoryservicesApi apiInstance = new DirectoryservicesApi();
        try {
            apiInstance.directoryservicesCacheRefreshGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryservicesApi#directoryservicesCacheRefreshGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DirectoryservicesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DirectoryservicesApi->new();

eval { 
    $api_instance->directoryservicesCacheRefreshGet();
};
if ($@) {
    warn "Exception when calling DirectoryservicesApi->directoryservicesCacheRefreshGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DirectoryservicesApi()

try: 
    api_instance.directoryservices_cache_refresh_get()
except ApiException as e:
    print("Exception when calling DirectoryservicesApi->directoryservicesCacheRefreshGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DirectoryservicesApi;

import java.io.File;
import java.util.*;

public class DirectoryservicesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DirectoryservicesApi apiInstance = new DirectoryservicesApi();
        try {
            apiInstance.directoryservicesGetStateGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling DirectoryservicesApi#directoryservicesGetStateGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DirectoryservicesApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DirectoryservicesApi->new();

eval { 
    $api_instance->directoryservicesGetStateGet();
};
if ($@) {
    warn "Exception when calling DirectoryservicesApi->directoryservicesGetStateGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DirectoryservicesApi()

try: 
    api_instance.directoryservices_get_state_get()
except ApiException as e:
    print("Exception when calling DirectoryservicesApi->directoryservicesGetStateGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.diskGet(limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->diskGet(limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.disk_get(limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling DiskApi->diskGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Disk_get_encrypted_0 body = ; // Disk_get_encrypted_0 | 
        try {
            apiInstance.diskGetEncryptedPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGetEncryptedPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Disk_get_encrypted_0->new(); # Disk_get_encrypted_0 | 

eval { 
    $api_instance->diskGetEncryptedPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGetEncryptedPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Disk_get_encrypted_0 |  (optional)

try: 
    api_instance.disk_get_encrypted_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskGetEncryptedPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        Boolean body = ; // Boolean | 
        try {
            apiInstance.diskGetUnusedPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskGetUnusedPost");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $body = WWW::SwaggerClient::Object::Boolean->new(); # Boolean | 

eval { 
    $api_instance->diskGetUnusedPost(body => $body);
};
if ($@) {
    warn "Exception when calling DiskApi->diskGetUnusedPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
body =  # Boolean |  (optional)

try: 
    api_instance.disk_get_unused_post(body=body)
except ApiException as e:
    print("Exception when calling DiskApi->diskGetUnusedPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DiskApi;

import java.io.File;
import java.util.*;

public class DiskApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basic
        HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
        basic.setUsername("YOUR USERNAME");
        basic.setPassword("YOUR PASSWORD");

        DiskApi apiInstance = new DiskApi();
        array[null] id = ; // array[null] | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        Boolean count = true; // Boolean | 
        String sort = sort_example; // String | 
        try {
            apiInstance.diskIdIdGet(id, limit, offset, count, sort);
        } catch (ApiException e) {
            System.err.println("Exception when calling DiskApi#diskIdIdGet");
            e.printStackTrace();
        }
    }
}

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DiskApi;

# Configure HTTP basic authorization: basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DiskApi->new();
my $id = []; # array[null] | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $count = true; # Boolean | 
my $sort = sort_example; # String | 

eval { 
    $api_instance->diskIdIdGet(id => $id, limit => $limit, offset => $offset, count => $count, sort => $sort);
};
if ($@) {
    warn "Exception when calling DiskApi->diskIdIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure HTTP basic authorization: basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DiskApi()
id =  # array[null] | 
limit = 56 # Integer |  (optional)
offset = 56 # Integer |  (optional)
count = true # Boolean |  (optional)
sort = sort_example # String |  (optional)

try: 
    api_instance.disk_id_id_get(id, limit=limit, offset=offset, count=count, sort=sort)
except ApiException as e:
    print("Exception when calling DiskApi->diskIdIdGet: %s\n" % e)